home *** CD-ROM | disk | FTP | other *** search
/ Chip 2007 January, February, March & April / Chip-Cover-CD-2007-02.iso / Pakiet bezpieczenstwa / mini Pentoo LiveCD 2006.1 / mpentoo-2006.1.iso / livecd.squashfs / usr / lib / python2.4 / urlparse.pyc (.txt) < prev    next >
Python Compiled Bytecode  |  2005-10-18  |  9KB  |  343 lines
  1. # Source Generated with Decompyle++
  2. # File: in.pyc (Python 2.4)
  3.  
  4. '''Parse (absolute and relative) URLs.
  5.  
  6. See RFC 1808: "Relative Uniform Resource Locators", by R. Fielding,
  7. UC Irvine, June 1995.
  8. '''
  9. __all__ = [
  10.     'urlparse',
  11.     'urlunparse',
  12.     'urljoin',
  13.     'urldefrag',
  14.     'urlsplit',
  15.     'urlunsplit']
  16. uses_relative = [
  17.     'ftp',
  18.     'http',
  19.     'gopher',
  20.     'nntp',
  21.     'imap',
  22.     'wais',
  23.     'file',
  24.     'https',
  25.     'shttp',
  26.     'mms',
  27.     'prospero',
  28.     'rtsp',
  29.     'rtspu',
  30.     '']
  31. uses_netloc = [
  32.     'ftp',
  33.     'http',
  34.     'gopher',
  35.     'nntp',
  36.     'telnet',
  37.     'imap',
  38.     'wais',
  39.     'file',
  40.     'mms',
  41.     'https',
  42.     'shttp',
  43.     'snews',
  44.     'prospero',
  45.     'rtsp',
  46.     'rtspu',
  47.     'rsync',
  48.     '',
  49.     'svn',
  50.     'svn+ssh']
  51. non_hierarchical = [
  52.     'gopher',
  53.     'hdl',
  54.     'mailto',
  55.     'news',
  56.     'telnet',
  57.     'wais',
  58.     'imap',
  59.     'snews',
  60.     'sip']
  61. uses_params = [
  62.     'ftp',
  63.     'hdl',
  64.     'prospero',
  65.     'http',
  66.     'imap',
  67.     'https',
  68.     'shttp',
  69.     'rtsp',
  70.     'rtspu',
  71.     'sip',
  72.     'mms',
  73.     '']
  74. uses_query = [
  75.     'http',
  76.     'wais',
  77.     'imap',
  78.     'https',
  79.     'shttp',
  80.     'mms',
  81.     'gopher',
  82.     'rtsp',
  83.     'rtspu',
  84.     'sip',
  85.     '']
  86. uses_fragment = [
  87.     'ftp',
  88.     'hdl',
  89.     'http',
  90.     'gopher',
  91.     'news',
  92.     'nntp',
  93.     'wais',
  94.     'https',
  95.     'shttp',
  96.     'snews',
  97.     'file',
  98.     'prospero',
  99.     '']
  100. scheme_chars = 'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789+-.'
  101. MAX_CACHE_SIZE = 20
  102. _parse_cache = { }
  103.  
  104. def clear_cache():
  105.     '''Clear the parse cache.'''
  106.     global _parse_cache
  107.     _parse_cache = { }
  108.  
  109.  
  110. def urlparse(url, scheme = '', allow_fragments = 1):
  111.     """Parse a URL into 6 components:
  112.     <scheme>://<netloc>/<path>;<params>?<query>#<fragment>
  113.     Return a 6-tuple: (scheme, netloc, path, params, query, fragment).
  114.     Note that we don't break the components up in smaller bits
  115.     (e.g. netloc is a single string) and we don't expand % escapes."""
  116.     tuple = urlsplit(url, scheme, allow_fragments)
  117.     (scheme, netloc, url, query, fragment) = tuple
  118.     if scheme in uses_params and ';' in url:
  119.         (url, params) = _splitparams(url)
  120.     else:
  121.         params = ''
  122.     return (scheme, netloc, url, params, query, fragment)
  123.  
  124.  
  125. def _splitparams(url):
  126.     if '/' in url:
  127.         i = url.find(';', url.rfind('/'))
  128.         if i < 0:
  129.             return (url, '')
  130.         
  131.     else:
  132.         i = url.find(';')
  133.     return (url[:i], url[i + 1:])
  134.  
  135.  
  136. def _splitnetloc(url, start = 0):
  137.     for c in '/?#':
  138.         delim = url.find(c, start)
  139.         if delim >= 0:
  140.             break
  141.             continue
  142.     else:
  143.         delim = len(url)
  144.     return (url[start:delim], url[delim:])
  145.  
  146.  
  147. def urlsplit(url, scheme = '', allow_fragments = 1):
  148.     """Parse a URL into 5 components:
  149.     <scheme>://<netloc>/<path>?<query>#<fragment>
  150.     Return a 5-tuple: (scheme, netloc, path, query, fragment).
  151.     Note that we don't break the components up in smaller bits
  152.     (e.g. netloc is a single string) and we don't expand % escapes."""
  153.     key = (url, scheme, allow_fragments)
  154.     cached = _parse_cache.get(key, None)
  155.     if cached:
  156.         return cached
  157.     
  158.     if len(_parse_cache) >= MAX_CACHE_SIZE:
  159.         clear_cache()
  160.     
  161.     netloc = query = fragment = ''
  162.     i = url.find(':')
  163.     if i > 0:
  164.         if url[:i] == 'http':
  165.             scheme = url[:i].lower()
  166.             url = url[i + 1:]
  167.             if url[:2] == '//':
  168.                 (netloc, url) = _splitnetloc(url, 2)
  169.             
  170.             if allow_fragments and '#' in url:
  171.                 (url, fragment) = url.split('#', 1)
  172.             
  173.             if '?' in url:
  174.                 (url, query) = url.split('?', 1)
  175.             
  176.             tuple = (scheme, netloc, url, query, fragment)
  177.             _parse_cache[key] = tuple
  178.             return tuple
  179.         
  180.         for c in url[:i]:
  181.             if c not in scheme_chars:
  182.                 break
  183.                 continue
  184.         else:
  185.             scheme = url[:i].lower()
  186.             url = url[i + 1:]
  187.     
  188.     if scheme in uses_netloc and url[:2] == '//':
  189.         (netloc, url) = _splitnetloc(url, 2)
  190.     
  191.     if allow_fragments and scheme in uses_fragment and '#' in url:
  192.         (url, fragment) = url.split('#', 1)
  193.     
  194.     if scheme in uses_query and '?' in url:
  195.         (url, query) = url.split('?', 1)
  196.     
  197.     tuple = (scheme, netloc, url, query, fragment)
  198.     _parse_cache[key] = tuple
  199.     return tuple
  200.  
  201.  
  202. def urlunparse(.0):
  203.     '''Put a parsed URL back together again.  This may result in a
  204.     slightly different, but equivalent URL, if the URL that was parsed
  205.     originally had redundant delimiters, e.g. a ? with an empty query
  206.     (the draft states that these are equivalent).'''
  207.     (scheme, netloc, url, params, query, fragment) = .0
  208.     if params:
  209.         url = '%s;%s' % (url, params)
  210.     
  211.     return urlunsplit((scheme, netloc, url, query, fragment))
  212.  
  213.  
  214. def urlunsplit(.0):
  215.     (scheme, netloc, url, query, fragment) = .0
  216.     if (netloc or scheme) and scheme in uses_netloc and url[:2] != '//':
  217.         if url and url[:1] != '/':
  218.             url = '/' + url
  219.         
  220.         if not netloc:
  221.             pass
  222.         url = '//' + '' + url
  223.     
  224.     if scheme:
  225.         url = scheme + ':' + url
  226.     
  227.     if query:
  228.         url = url + '?' + query
  229.     
  230.     if fragment:
  231.         url = url + '#' + fragment
  232.     
  233.     return url
  234.  
  235.  
  236. def urljoin(base, url, allow_fragments = 1):
  237.     '''Join a base URL and a possibly relative URL to form an absolute
  238.     interpretation of the latter.'''
  239.     if not base:
  240.         return url
  241.     
  242.     if not url:
  243.         return base
  244.     
  245.     (bscheme, bnetloc, bpath, bparams, bquery, bfragment) = urlparse(base, '', allow_fragments)
  246.     (scheme, netloc, path, params, query, fragment) = urlparse(url, bscheme, allow_fragments)
  247.     if scheme != bscheme or scheme not in uses_relative:
  248.         return url
  249.     
  250.     if scheme in uses_netloc:
  251.         if netloc:
  252.             return urlunparse((scheme, netloc, path, params, query, fragment))
  253.         
  254.         netloc = bnetloc
  255.     
  256.     if path[:1] == '/':
  257.         return urlunparse((scheme, netloc, path, params, query, fragment))
  258.     
  259.     if not path and params or query:
  260.         return urlunparse((scheme, netloc, bpath, bparams, bquery, fragment))
  261.     
  262.     segments = bpath.split('/')[:-1] + path.split('/')
  263.     if segments[-1] == '.':
  264.         segments[-1] = ''
  265.     
  266.     while '.' in segments:
  267.         segments.remove('.')
  268.     while None:
  269.         i = 1
  270.         n = len(segments) - 1
  271.         while i < n:
  272.             if segments[i] == '..' and segments[i - 1] not in ('', '..'):
  273.                 del segments[i - 1:i + 1]
  274.                 break
  275.             
  276.             i = i + 1
  277.         break
  278.     if segments == [
  279.         '',
  280.         '..']:
  281.         segments[-1] = ''
  282.     elif len(segments) >= 2 and segments[-1] == '..':
  283.         segments[-2:] = [
  284.             '']
  285.     
  286.     return urlunparse((scheme, netloc, '/'.join(segments), params, query, fragment))
  287.  
  288.  
  289. def urldefrag(url):
  290.     '''Removes any existing fragment from URL.
  291.  
  292.     Returns a tuple of the defragmented URL and the fragment.  If
  293.     the URL contained no fragments, the second element is the
  294.     empty string.
  295.     '''
  296.     if '#' in url:
  297.         (s, n, p, a, q, frag) = urlparse(url)
  298.         defrag = urlunparse((s, n, p, a, q, ''))
  299.         return (defrag, frag)
  300.     else:
  301.         return (url, '')
  302.  
  303. test_input = '\n      http://a/b/c/d\n\n      g:h        = <URL:g:h>\n      http:g     = <URL:http://a/b/c/g>\n      http:      = <URL:http://a/b/c/d>\n      g          = <URL:http://a/b/c/g>\n      ./g        = <URL:http://a/b/c/g>\n      g/         = <URL:http://a/b/c/g/>\n      /g         = <URL:http://a/g>\n      //g        = <URL:http://g>\n      ?y         = <URL:http://a/b/c/d?y>\n      g?y        = <URL:http://a/b/c/g?y>\n      g?y/./x    = <URL:http://a/b/c/g?y/./x>\n      .          = <URL:http://a/b/c/>\n      ./         = <URL:http://a/b/c/>\n      ..         = <URL:http://a/b/>\n      ../        = <URL:http://a/b/>\n      ../g       = <URL:http://a/b/g>\n      ../..      = <URL:http://a/>\n      ../../g    = <URL:http://a/g>\n      ../../../g = <URL:http://a/../g>\n      ./../g     = <URL:http://a/b/g>\n      ./g/.      = <URL:http://a/b/c/g/>\n      /./g       = <URL:http://a/./g>\n      g/./h      = <URL:http://a/b/c/g/h>\n      g/../h     = <URL:http://a/b/c/h>\n      http:g     = <URL:http://a/b/c/g>\n      http:      = <URL:http://a/b/c/d>\n      http:?y         = <URL:http://a/b/c/d?y>\n      http:g?y        = <URL:http://a/b/c/g?y>\n      http:g?y/./x    = <URL:http://a/b/c/g?y/./x>\n'
  304.  
  305. def test():
  306.     import sys as sys
  307.     base = ''
  308.     if sys.argv[1:]:
  309.         fn = sys.argv[1]
  310.         if fn == '-':
  311.             fp = sys.stdin
  312.         else:
  313.             fp = open(fn)
  314.     else:
  315.         import StringIO as StringIO
  316.         fp = StringIO.StringIO(test_input)
  317.     while None:
  318.         line = fp.readline()
  319.         if not line:
  320.             break
  321.         
  322.         words = line.split()
  323.         if not words:
  324.             continue
  325.         
  326.         url = words[0]
  327.         parts = urlparse(url)
  328.         print '%-10s : %s' % (url, parts)
  329.         abs = urljoin(base, url)
  330.         if not base:
  331.             base = abs
  332.         
  333.         wrapped = '<URL:%s>' % abs
  334.         print '%-10s = %s' % (url, wrapped)
  335.         if len(words) == 3 and words[1] == '=':
  336.             if wrapped != words[2]:
  337.                 print 'EXPECTED', words[2], '!!!!!!!!!!'
  338.             
  339.  
  340. if __name__ == '__main__':
  341.     test()
  342.  
  343.